/**
 * 数组对象根据某个属性进行排序 从小排到大 顺序
 * @param {传入的数据} data
 * @param {字段} prop
 * @returns {Array} data
 */
export function compareArraySort(data, prop) {
  data.sort(compareSort(prop))
  return data
}

/**
 * 数组对象根据某个属性进行排序 从大排到小 降序
 * @param {传入的数据} data
 * @param {字段} prop
 * @returns {Array} data
 */
export function compareArrayDesc(data, prop) {
  data.sort(compareDesc(prop))
  return data
}

/**
 * 从小排到大
 * @param {字段名}} key
 */
function compareSort(key) {
  return function(value1, value2) {
    var val1 = value1[key]
    var val2 = value2[key]
    return val1 - val2
  }
}

/**
 * 从大排到小
 * @param {字段名}} key
 */
function compareDesc(key) {
  return function(value1, value2) {
    var val1 = value1[key]
    var val2 = value2[key]
    return val2 - val1
  }
}

/**
 * 数组从小排到大
 * @param { num1 } a
 * @param { num2 } b
 */
export function sortNumber(a, b) {
  return a - b
}

/**
 * 数组从大排到小
 * @param { num1 } a
 * @param { num2 } b
 */
export function descNumber(a, b) {
  return b - a
}

export function descArray(arr) {
  return arr.sort(descNumber)
}

/**
 * @function 求两个数组的交集
 * @description 数组为简单数组
 * @returns {array} 正常的数组
 * */
export const intersection = (aArray, bArray) => {
  const bArraySet = new Set(bArray)
  const resultArray = aArray.filter(item => bArraySet.has(item))
  return Array.from(resultArray)
}

/**
 * @function 求两个数组的并集
 * @description 数组为简单数组
 * @returns {array} 正常的数组
 * */
export const union = (aArray, bArray) => {
  const resultArray = new Set([...aArray, ...bArray])
  return Array.from(resultArray)
}

/**
 * @function 求两个数组的差集;数组aArray相对于bArray所没有的
 * @description 数组为简单数组
 * @returns {array} 正常的数组
 * */
export const difference = (aArray, bArray) => {
  const bArraySet = new Set(bArray)
  const resultArray = aArray.filter(item => !bArraySet.has(item))
  return Array.from(resultArray)
}

/**
 * @function  获取集合运算的结果数组
 * @param {string} key 数组对象的唯一标识
 * @param {function} functionAction 需要调用的函数
 * @param {array} aArray
 * @param {array} bArray
 * @returns {array} 正常的数组
 * */
export const getResultArray = (key, functionAction, aArray, bArray) => {
  const aArraySimple = aArray.map(i => i[key]) // 根据唯一标识对象数组转换为简单数组
  const bArraySimple = bArray.map(i => i[key])
  const allData = [...aArray, ...bArray]
  const resultArraySimple = Array.from(functionAction(aArraySimple, bArraySimple))
  return resultArraySimple.map(i => allData.find(j => j[key] === i))
}

// console.log('aArray: ', aArray);
// console.log('bArray: ', bArray);
// console.log('并集', getResultArray('id', union, aArray, bArray));
// console.log('交集', getResultArray('id', intersection, aArray, bArray));
// console.log('差集', getResultArray('id', difference, aArray, bArray));

/**
 * 数组去重
 * @param { 数组 | Array} arr
 * @returns 返回去重后的数组 | Array
 */
export function unique(arr) {
  return Array.from(new Set(arr))
}

/**
 * 基于 Arr1 的数据差集 1维数据
 * @param { 数据源1 } arr1
 * @param { 数据源2 } arr2
 * @returns { 新数组 | Array}
 */
export function diffArr(arr1, arr2) {
  return [...new Set(arr1)].filter(item => !new Set(arr2).has(item))
}

export function findItem(arr, prop, value) {
  return arr.find(item => item[prop] === value)
}

// export function
